package com.zzuli.yxypre.utils;

import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.apache.commons.lang.CharUtils;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

/**
 * 定义前缀树，实现敏感词过滤
 * @auther pony
 * @create 2023-05-18 21:20
 */
@Component
public class SensitiveFilter {

    // 替换敏感词
    private static final String REPLACEMENT = "***";

    // 根节点
    private TrieNode rootNode = new TrieNode();

    // 初始化 当容器实例化这个Bean以后，在调用构造方法之后，调用这个方法
    // 这个bean 项目启动时就会被初始化
    @PostConstruct
    public void init(){
        try(
            // 1、读取敏感词文件
            InputStream is = this.getClass().getClassLoader().getResourceAsStream("sensitive-words.txt");
            // 缓冲流
            BufferedReader reader = new BufferedReader(new InputStreamReader(is))
        ) {
            // 敏感词
            String keyword;
            while ((keyword = reader.readLine())!=null){
                //添加到前缀数
                this.addKeyword(keyword);
            }
        } catch (IOException e) {
            e.printStackTrace();
        };

    }

    // 将一个敏感词添加到前缀数中去
    private void addKeyword(String keyword){
        TrieNode tempNode = rootNode;
        for (int i = 0; i < keyword.length(); i++) {
            char c = keyword.charAt(i);
            // 查找是否有子节点
            TrieNode subNode = tempNode.getSubNode(c);

            // 为空，进行初始化
            if (subNode == null){
                subNode = new TrieNode();
                tempNode.addSubNode(c, subNode);
            }

            // 指向了节点，进入下一轮循环
            tempNode = subNode;

            // 设置结束标识
            if (i == keyword.length()-1){
                tempNode.setKeywordEnd(true);
            }
        }

    }

    /**
     * 过滤敏感词
     * @param text 待过滤的文本
     * @return 过滤后的文本
     */
    public String filter(String text){
        // 非空判断
        if(StringUtils.isBlank(text)){
            // 为空
            return null;
        }

        // 指针1
        TrieNode tempNode = rootNode;
        // 指针2
        int begin = 0;
        // 指针3
        int position = 0;
        // 结果
        StringBuilder sb = new StringBuilder();

        while(begin < text.length()){
            if(position < text.length()) {
                Character c = text.charAt(position);

                // 跳过符号
                if (isSymbol(c)) {
                    if (tempNode == rootNode) {
                        begin++;
                        sb.append(c);
                    }
                    position++;
                    continue;
                }

                // 检查下级节点
                tempNode = tempNode.getSubNode(c);
                if (tempNode == null) {
                    // 以begin开头的字符串不是敏感词
                    sb.append(text.charAt(begin));
                    // 进入下一个位置
                    position = ++begin;
                    // 重新指向根节点
                    tempNode = rootNode;
                }
                // 发现敏感词
                else if (tempNode.isKeywordEnd()) {
                    sb.append(REPLACEMENT);
                    begin = ++position;
                }
                // 检查下一个字符
                else {
                    position++;
                }
            }
            // position遍历越界仍未匹配到敏感词
            else{
                sb.append(text.charAt(begin));
                position = ++begin;
                tempNode = rootNode;
            }
        }

        return sb.toString() ;
    }

    // 判断是否是符号
    private boolean isSymbol(Character c){
        // 0x2E80 ~ 0x9FFF 是东亚文字范围
        return !CharUtils.isAsciiAlphanumeric(c) && (c<0x2E80 || c>0x9FFF);
    }

    // 前缀树
    private class TrieNode{
        // 结束标志，是不是一个敏感词或是不是一个词的结尾
        private boolean isKeywordEnd = false;

        // 子节点（key是下级字符，value是下级节点）
        private Map<Character, TrieNode> subNodes = new HashMap<>();

        public boolean isKeywordEnd() {
            return isKeywordEnd;
        }

        public void setKeywordEnd(boolean keywordEnd) {
            isKeywordEnd = keywordEnd;
        }

        // 添加子节点
        public void addSubNode(Character c, TrieNode node){
            subNodes.put(c, node);
        }

        // 获取子节点
        public TrieNode getSubNode(Character c){
            return subNodes.get(c);
        }
    }


}
